package com.tiamo.chatgpt.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author luozhiwei
 * @date 2023/6/5 下午11:45
 */
@Component
@Slf4j
public class RedisUtil {

    @Resource
    private StringRedisTemplate stringTemplate;
    @Resource
    private RedisTemplate<String, Object> template;

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        try {
            return template.opsForValue().get(key);
        } catch (Exception e) {
            log.error(e.getMessage());
            return null;
        }
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            template.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                template.opsForValue().set(key, value, time, TimeUnit.MILLISECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key
     */
    public void del(String key) {
        if (StringUtils.isNotBlank(key)) {
            template.delete(key);
        }
    }

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> listGet(String key, long start, long end) {
        try {
            return template.opsForList().range(key, start, end);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获取list缓存的内容All  支持类型转换
     *
     * @param key   键
     * @param clazz 类型
     * @return
     */
    public <T> List<T> listGetAllAndConvert(String key, Class<T> clazz) {
        try {
            List<Object> range = template.opsForList().range(key, 0, -1);
            if (CollUtil.isEmpty(range)) {
                return null;
            }
            return Convert.toList(clazz, range);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获取list缓存的内容All
     *
     * @param key 键
     * @return
     */
    public List<Object> listGetAll(String key) {
        try {
            return template.opsForList().range(key, 0, -1);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 从右边新增数据
     *
     * @param key   键
     * @param value
     * @return
     */
    public boolean listSet(String key, Object value) {
        try {
            template.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return false;
        }
    }

    /**
     * 从右边新增数据
     *
     * @param key   键
     * @param value
     * @return
     */
    public <T> boolean listSetAll(String key, List<T> value) {
        try {
            value.stream().forEach(a -> {
                listSet(key, a);
            });
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return false;
        }
    }

    /**
     * 从左边删除数据
     *
     * @param key 键
     * @return
     */
    public boolean listLeftDel(String key) {
        try {
            template.opsForList().leftPop(key);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return false;
        }
    }

    /**
     * set类型
     * 从右边新增数据
     *
     * @param key   键
     * @param value
     * @return
     */
    public boolean seSet(String key, Object value) {
        try {
            template.opsForSet().add(key, value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return false;
        }
    }

    /**
     * set类型
     * 获取所有数据
     *
     * @param key   键
     * @param clazz
     * @return
     */
    public <T> Set<T> seGetAllConvert(String key, Class<T> clazz) {
        try {
            Set<Object> members = template.opsForSet().members(key);
            return Convert.toSet(clazz, members);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return null;
        }
    }
}
